// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// go:build ignore 

// 为小型malloc大小的类生成表。
// 
// 见malloc。浏览概览。
// 
// 选择大小类别，以便将分配
// 请求四舍五入到下一个大小类别最多浪费12.5%（1.125x）。
// 
// 每个size类都有自己的页面计数，分配给
// 并在需要size类的新对象时切碎。
// 选择页面计数，以便将运行的
// 页面分割为给定大小的对象，最多浪费12.5%（1.125x）
// 内存。此处的截止值不必为
// 与上述相同。
// 
// 这两种废物源会成倍增加，因此，对于上述限制，最糟糕的情况可能是，某些
// 大小的分配可能会产生26.6%（1.266x）的开销。
// 实际上，对于给定大小的
// 来说，只有一种垃圾会起作用（大小<512垃圾主要集中在汇总上，大小>512垃圾主要集中在切纸上）。
// 对于非常小的尺寸，对齐约束迫使
// 开销更高。

package main

import (
	"bytes"
	"flag"
	"fmt"
	"go/format"
	"io"
	"log"
	"math"
	"math/bits"
	"os"
)

// 生成msize。转到

var stdout = flag.Bool("stdout", false, "write to stdout instead of sizeclasses.go")

func main() {
	flag.Parse()

	var b bytes.Buffer
	fmt.Fprintln(&b, "// 由mksizelasses生成的代码。去不要编辑。“）
	fmt.Fprintln(&b, "// go:generate go run mksizelasses.go”）
	fmt.Fprintln(&b)
	fmt.Fprintln(&b, "package runtime")
	classes := makeClasses()

	printComment(&b, classes)

	printClasses(&b, classes)

	out, err := format.Source(b.Bytes())
	if err != nil {
		log.Fatal(err)
	}
	if *stdout {
		_, err = os.Stdout.Write(out)
	} else {
		err = os.WriteFile("sizeclasses.go", out, 0666)
	}
	if err != nil {
		log.Fatal(err)
	}
}

const (
	// 我们使用并将传输到运行时的常量。
	maxSmallSize = 32 << 10
	smallSizeDiv = 8
	smallSizeMax = 1024
	largeSizeDiv = 128
	pageShift    = 13

	// 派生常数。
	pageSize = 1 << pageShift
)

type class struct {
	size   int // 最大大小
	npages int // 页数
}

func powerOfTwo(x int) bool {
	return x != 0 && x&(x-1) == 0
}

func makeClasses() []class {
	var classes []class

	classes = append(classes, class{}) // 类#0是一个伪条目

	align := 8
	for size := align; size <= maxSmallSize; size += align {
		if powerOfTwo(size) { // 偶尔进行一次凹凸对齐
			if size >= 2048 {
				align = 256
			} else if size >= 128 {
				align = size / 8
			} else if size >= 32 {
				align = 16 // 堆位图假定分配为16字节对齐>=32字节。
			}
		}
		if !powerOfTwo(align) {
			panic("incorrect alignment")
		}

		// 将AllocPages设置得足够大，以便
		// 剩余空间不到总数的1/8，
		// 因此浪费的空间最多为12.5%。
		allocsize := pageSize
		for allocsize%size > allocsize/8 {
			allocsize += pageSize
		}
		npages := allocsize / pageSize

		// 如果上一个sizeclass选择了相同的
		// 分配大小，并将相同数量的
		// 对象放入页面，那么我们最好使用这个大小，而不是两个不同大小的
		// 对象。
		if len(classes) > 1 && npages == classes[len(classes)-1].npages && allocsize/size == allocsize/classes[len(classes)-1].size {
			classes[len(classes)-1].size = size
			continue
		}
		classes = append(classes, class{size: size, npages: npages})
	}

	// 如果我们能将相同数量的较大对象放入相同数量的页面中，请增加对象大小。例如，我们选择
	// 上方的8448号，7页中有6个对象。但是我们可以很好地使用对象大小9472，
	// 这也是7页中的6个对象，但是+1024字节（+12.12%）。
	// 我们需要至少保持大范围的EDIV对齐，否则
	// sizeToClass将无法工作。
	for i := range classes {
		if i == 0 {
			continue
		}
		c := &classes[i]
		psize := c.npages * pageSize
		new_size := (psize / (psize / c.size)) &^ (largeSizeDiv - 1)
		if new_size > c.size {
			c.size = new_size
		}
	}

	if len(classes) != 68 {
		panic("number of size classes has changed")
	}

	for i := range classes {
		computeDivMagic(&classes[i])
	}

	return classes
}

// computeDivMagic检查计算对象所需的除法
// 可以使用32位乘法计算跨度偏移量的索引。
// n/c.size实现为（n*（^uint32（0）/uint32（c.size）+1））>>32 
// 对于所有0<=n<=c.npages*pageSize 
func computeDivMagic(c *class) {
	// 除数
	d := c.size
	if d == 0 {
		return
	}

	// 公式需要计算的最大输入值。
	max := c.npages * pageSize

	// 如[1]所述，如果n和d是无符号n位整数，我们可以将n/d计算为⌊n*c/2^F⌋, c在哪里⌈二楼/日⌉ F是
	// 用：
	// 
	// 算法2：在无符号
	// 和缩放近似倒数的算法。
	// 整数的情况下，选择小数位数
	// 
	// 如果d是二的幂，那么
	// 让F← 日志₂（d） c=1。
	// 否则
	// 让F← N+L，其中L是最小的整数
	// ≤ （2^（N+L）mod d）+2^ L.
	// 如果
	// 
	// [1]“直接计算更快的余数：应用于
	// 编译器和软件库”丹尼尔·莱米尔，欧文·卡斯尔，
	// Nathan Kurxiv:1902.01961 
	// 
	// 为了最大限度地减少引入错误的风险，我们完全按照所述实现了
	// 算法，而不是试图使其适应
	// 符合典型的围棋习惯用法。
	N := bits.Len(uint(max))
	var F int
	if powerOfTwo(d) {
		F = int(math.Log2(float64(d)))
		if d != 1<<F {
			panic("imprecise log2")
		}
	} else {
		for L := 0; ; L++ {
			if d <= ((1<<(N+L))%d)+(1<<L) {
				F = N + L
				break
			}
		}
	}

	// 此外，本文还指出，F是所需的最小分数
	// 位。我们使用32位，因为它适用于所有大小的
	// 类，并且在我们支持的所有CPU架构上都很快。
	if F > 32 {
		fmt.Printf("d=%d max=%d N=%d F=%d\n", c.size, max, N, F)
		panic("size class requires more than 32 bits of precision")
	}

	// 使用
	// 由运行时完成。
	m := ^uint32(0)/uint32(c.size) + 1
	for n := 0; n <= max; n++ {
		if uint32((uint64(n)*uint64(m))>>32) != uint32(n/c.size) {
			fmt.Printf("d=%d max=%d m=%d n=%d\n", d, max, m, n)
			panic("bad 32-bit multiply magic")
		}
	}
}

func printComment(w io.Writer, classes []class) {
	fmt.Fprintf(w, "// /%-5s%-9s%-10s%-7s%-10s%-9s%-9s\n，“类”、“字节/obj”、“字节/span”、“对象”、“尾部浪费”、“最大浪费”、“最小对齐”）
	prevSize := 0
	var minAligns [pageShift + 1]int
	for i, c := range classes {
		if i == 0 {
			continue
		}
		spanSize := c.npages * pageSize
		objects := spanSize / c.size
		tailWaste := spanSize - c.size*(spanSize/c.size)
		maxWaste := float64((c.size-prevSize-1)*objects+tailWaste) / float64(spanSize)
		alignBits := bits.TrailingZeros(uint(c.size))
		if alignBits > pageShift {
			// 对象对齐在页面对齐时被限制
			alignBits = pageShift
		}
		for i := range minAligns {
			if i > alignBits {
				minAligns[i] = 0
			} else if minAligns[i] == 0 {
				minAligns[i] = c.size
			}
		}
		prevSize = c.size
		fmt.Fprintf(w, "// /%5d%9d%10d%7d%10d%8.2f%%%9d\n”，i，c.大小，跨距大小，对象，尾部浪费，100*maxWaste，1<<alignBits）
	}
	fmt.Fprintf(w, "\n")

	fmt.Fprintf(w, "// /%-9s%-4s%-12s\n，“对齐”，“位”，“最小对象大小”）
	for bits, size := range minAligns {
		if size == 0 {
			break
		}
		if bits+1 < len(minAligns) && size == minAligns[bits+1] {
			continue
		}
		fmt.Fprintf(w, "// /%9d%4d%12d\n”，1<<bits，bits，size）
	}
	fmt.Fprintf(w, "\n")
}

func printClasses(w io.Writer, classes []class) {
	fmt.Fprintln(w, "const (")
	fmt.Fprintf(w, "_MaxSmallSize = %d\n", maxSmallSize)
	fmt.Fprintf(w, "smallSizeDiv = %d\n", smallSizeDiv)
	fmt.Fprintf(w, "smallSizeMax = %d\n", smallSizeMax)
	fmt.Fprintf(w, "largeSizeDiv = %d\n", largeSizeDiv)
	fmt.Fprintf(w, "_NumSizeClasses = %d\n", len(classes))
	fmt.Fprintf(w, "_PageShift = %d\n", pageShift)
	fmt.Fprintln(w, ")")

	fmt.Fprint(w, "var class_to_size = [_NumSizeClasses]uint16 {")
	for _, c := range classes {
		fmt.Fprintf(w, "%d,", c.size)
	}
	fmt.Fprintln(w, "}")

	fmt.Fprint(w, "var class_to_allocnpages = [_NumSizeClasses]uint8 {")
	for _, c := range classes {
		fmt.Fprintf(w, "%d,", c.npages)
	}
	fmt.Fprintln(w, "}")

	fmt.Fprint(w, "var class_to_divmagic = [_NumSizeClasses]uint32 {")
	for _, c := range classes {
		if c.size == 0 {
			fmt.Fprintf(w, "0,")
			continue
		}
		fmt.Fprintf(w, "^uint32(0)/%d+1,", c.size)
	}
	fmt.Fprintln(w, "}")

	// 从大小映射到大小级别，适用于小尺寸。
	sc := make([]int, smallSizeMax/smallSizeDiv+1)
	for i := range sc {
		size := i * smallSizeDiv
		for j, c := range classes {
			if c.size >= size {
				sc[i] = j
				break
			}
		}
	}
	fmt.Fprint(w, "var size_to_class8 = [smallSizeMax/smallSizeDiv+1]uint8 {")
	for _, v := range sc {
		fmt.Fprintf(w, "%d,", v)
	}
	fmt.Fprintln(w, "}")

	// 针对大尺寸，从尺寸到尺寸类别进行映射。
	sc = make([]int, (maxSmallSize-smallSizeMax)/largeSizeDiv+1)
	for i := range sc {
		size := smallSizeMax + i*largeSizeDiv
		for j, c := range classes {
			if c.size >= size {
				sc[i] = j
				break
			}
		}
	}
	fmt.Fprint(w, "var size_to_class128 = [(_MaxSmallSize-smallSizeMax)/largeSizeDiv+1]uint8 {")
	for _, v := range sc {
		fmt.Fprintf(w, "%d,", v)
	}
	fmt.Fprintln(w, "}")
}
